home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / src / gdb-4.12 / bfd / coff-mip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-03  |  39.6 KB  |  1,319 lines
  1. /* BFD back-end for MIPS Extended-Coff files.
  2.    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  3.    Original version by Per Bothner.
  4.    Full support added by Ian Lance Taylor, ian@cygnus.com.
  5.  
  6. This file is part of BFD, the Binary File Descriptor library.
  7.  
  8. This program is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2 of the License, or
  11. (at your option) any later version.
  12.  
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. #include "bfd.h"
  23. #include "sysdep.h"
  24. #include "bfdlink.h"
  25. #include "libbfd.h"
  26. #include "coff/internal.h"
  27. #include "coff/sym.h"
  28. #include "coff/symconst.h"
  29. #include "coff/ecoff.h"
  30. #include "coff/mips.h"
  31. #include "libcoff.h"
  32. #include "libecoff.h"
  33.  
  34. /* Prototypes for static functions.  */
  35.  
  36. static boolean mips_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
  37. static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
  38.                           struct internal_reloc *));
  39. static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
  40.                            const struct internal_reloc *,
  41.                            PTR));
  42. static void mips_adjust_reloc_in PARAMS ((bfd *,
  43.                       const struct internal_reloc *,
  44.                       arelent *));
  45. static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
  46.                        struct internal_reloc *));
  47. static bfd_reloc_status_type mips_generic_reloc PARAMS ((bfd *abfd,
  48.                              arelent *reloc,
  49.                              asymbol *symbol,
  50.                              PTR data,
  51.                              asection *section,
  52.                              bfd *output_bfd,
  53.                              char **error));
  54. static bfd_reloc_status_type mips_refhi_reloc PARAMS ((bfd *abfd,
  55.                                arelent *reloc,
  56.                                asymbol *symbol,
  57.                                PTR data,
  58.                                asection *section,
  59.                                bfd *output_bfd,
  60.                                char **error));
  61. static bfd_reloc_status_type mips_reflo_reloc PARAMS ((bfd *abfd,
  62.                                arelent *reloc,
  63.                                asymbol *symbol,
  64.                                PTR data,
  65.                                asection *section,
  66.                                bfd *output_bfd,
  67.                                char **error));
  68. static bfd_reloc_status_type mips_gprel_reloc PARAMS ((bfd *abfd,
  69.                                arelent *reloc,
  70.                                asymbol *symbol,
  71.                                PTR data,
  72.                                asection *section,
  73.                                bfd *output_bfd,
  74.                                char **error));
  75. static void mips_relocate_refhi PARAMS ((struct internal_reloc *refhi,
  76.                      struct internal_reloc *reflo,
  77.                      bfd *input_bfd,
  78.                      asection *input_section,
  79.                      bfd_byte *contents,
  80.                      bfd_vma relocation));
  81. static boolean mips_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
  82.                           bfd *, asection *,
  83.                           bfd_byte *, PTR));
  84.  
  85. /* ECOFF has COFF sections, but the debugging information is stored in
  86.    a completely different format.  ECOFF targets use some of the
  87.    swapping routines from coffswap.h, and some of the generic COFF
  88.    routines in coffgen.c, but, unlike the real COFF targets, do not
  89.    use coffcode.h itself.
  90.  
  91.    Get the generic COFF swapping routines, except for the reloc,
  92.    symbol, and lineno ones.  Give them ECOFF names.  */
  93. #define MIPSECOFF
  94. #define NO_COFF_RELOCS
  95. #define NO_COFF_SYMBOLS
  96. #define NO_COFF_LINENOS
  97. #define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
  98. #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
  99. #define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
  100. #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
  101. #define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
  102. #define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
  103. #include "coffswap.h"
  104.  
  105. /* Get the ECOFF swapping routines.  */
  106. #define ECOFF_32
  107. #include "ecoffswap.h"
  108.  
  109. /* How to process the various relocs types.  */
  110.  
  111. static reloc_howto_type mips_howto_table[] =
  112. {
  113.   /* Reloc type 0 is ignored.  The reloc reading code ensures that
  114.      this is a reference to the .abs section, which will cause
  115.      bfd_perform_relocation to do nothing.  */
  116.   HOWTO (MIPS_R_IGNORE,    /* type */
  117.      0,            /* rightshift */
  118.      0,            /* size (0 = byte, 1 = short, 2 = long) */
  119.      8,            /* bitsize */
  120.      false,            /* pc_relative */
  121.      0,            /* bitpos */
  122.      complain_overflow_dont, /* complain_on_overflow */
  123.      0,            /* special_function */
  124.      "IGNORE",        /* name */
  125.      false,            /* partial_inplace */
  126.      0,            /* src_mask */
  127.      0,            /* dst_mask */
  128.      false),        /* pcrel_offset */
  129.  
  130.   /* A 16 bit reference to a symbol, normally from a data section.  */
  131.   HOWTO (MIPS_R_REFHALF,    /* type */
  132.      0,            /* rightshift */
  133.      1,            /* size (0 = byte, 1 = short, 2 = long) */
  134.      16,            /* bitsize */
  135.      false,            /* pc_relative */
  136.      0,            /* bitpos */
  137.      complain_overflow_bitfield, /* complain_on_overflow */
  138.      mips_generic_reloc,    /* special_function */
  139.      "REFHALF",        /* name */
  140.      true,            /* partial_inplace */
  141.      0xffff,        /* src_mask */
  142.      0xffff,        /* dst_mask */
  143.      false),        /* pcrel_offset */
  144.  
  145.   /* A 32 bit reference to a symbol, normally from a data section.  */
  146.   HOWTO (MIPS_R_REFWORD,    /* type */
  147.      0,            /* rightshift */
  148.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  149.      32,            /* bitsize */
  150.      false,            /* pc_relative */
  151.      0,            /* bitpos */
  152.      complain_overflow_bitfield, /* complain_on_overflow */
  153.      mips_generic_reloc,    /* special_function */
  154.      "REFWORD",        /* name */
  155.      true,            /* partial_inplace */
  156.      0xffffffff,        /* src_mask */
  157.      0xffffffff,        /* dst_mask */
  158.      false),        /* pcrel_offset */
  159.  
  160.   /* A 26 bit absolute jump address.  */
  161.   HOWTO (MIPS_R_JMPADDR,    /* type */
  162.      2,            /* rightshift */
  163.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  164.      26,            /* bitsize */
  165.      false,            /* pc_relative */
  166.      0,            /* bitpos */
  167.      complain_overflow_dont, /* complain_on_overflow */
  168.                  /* This needs complex overflow
  169.                    detection, because the upper four
  170.                    bits must match the PC.  */
  171.      mips_generic_reloc,    /* special_function */
  172.      "JMPADDR",        /* name */
  173.      true,            /* partial_inplace */
  174.      0x3ffffff,        /* src_mask */
  175.      0x3ffffff,        /* dst_mask */
  176.      false),        /* pcrel_offset */
  177.  
  178.   /* The high 16 bits of a symbol value.  Handled by the function
  179.      mips_refhi_reloc.  */
  180.   HOWTO (MIPS_R_REFHI,        /* type */
  181.      16,            /* rightshift */
  182.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  183.      16,            /* bitsize */
  184.      false,            /* pc_relative */
  185.      0,            /* bitpos */
  186.      complain_overflow_bitfield, /* complain_on_overflow */
  187.      mips_refhi_reloc,    /* special_function */
  188.      "REFHI",        /* name */
  189.      true,            /* partial_inplace */
  190.      0xffff,        /* src_mask */
  191.      0xffff,        /* dst_mask */
  192.      false),        /* pcrel_offset */
  193.  
  194.   /* The low 16 bits of a symbol value.  */
  195.   HOWTO (MIPS_R_REFLO,        /* type */
  196.      0,            /* rightshift */
  197.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  198.      16,            /* bitsize */
  199.      false,            /* pc_relative */
  200.      0,            /* bitpos */
  201.      complain_overflow_dont, /* complain_on_overflow */
  202.      mips_reflo_reloc,    /* special_function */
  203.      "REFLO",        /* name */
  204.      true,            /* partial_inplace */
  205.      0xffff,        /* src_mask */
  206.      0xffff,        /* dst_mask */
  207.      false),        /* pcrel_offset */
  208.  
  209.   /* A reference to an offset from the gp register.  Handled by the
  210.      function mips_gprel_reloc.  */
  211.   HOWTO (MIPS_R_GPREL,        /* type */
  212.      0,            /* rightshift */
  213.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  214.      16,            /* bitsize */
  215.      false,            /* pc_relative */
  216.      0,            /* bitpos */
  217.      complain_overflow_signed, /* complain_on_overflow */
  218.      mips_gprel_reloc,    /* special_function */
  219.      "GPREL",        /* name */
  220.      true,            /* partial_inplace */
  221.      0xffff,        /* src_mask */
  222.      0xffff,        /* dst_mask */
  223.      false),        /* pcrel_offset */
  224.  
  225.   /* A reference to a literal using an offset from the gp register.
  226.      Handled by the function mips_gprel_reloc.  */
  227.   HOWTO (MIPS_R_LITERAL,    /* type */
  228.      0,            /* rightshift */
  229.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  230.      16,            /* bitsize */
  231.      false,            /* pc_relative */
  232.      0,            /* bitpos */
  233.      complain_overflow_signed, /* complain_on_overflow */
  234.      mips_gprel_reloc,    /* special_function */
  235.      "LITERAL",        /* name */
  236.      true,            /* partial_inplace */
  237.      0xffff,        /* src_mask */
  238.      0xffff,        /* dst_mask */
  239.      false)            /* pcrel_offset */
  240. };
  241.  
  242. #define MIPS_HOWTO_COUNT \
  243.   (sizeof mips_howto_table / sizeof mips_howto_table[0])
  244.  
  245. /* See whether the magic number matches.  */
  246.  
  247. static boolean
  248. mips_ecoff_bad_format_hook (abfd, filehdr)
  249.      bfd *abfd;
  250.      PTR filehdr;
  251. {
  252.   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
  253.  
  254.   switch (internal_f->f_magic)
  255.     {
  256.     case MIPS_MAGIC_1:
  257.       /* I don't know what endianness this implies.  */
  258.       return true;
  259.  
  260.     case MIPS_MAGIC_BIG:
  261.     case MIPS_MAGIC_BIG2:
  262.     case MIPS_MAGIC_BIG3:
  263.       return abfd->xvec->byteorder_big_p;
  264.  
  265.     case MIPS_MAGIC_LITTLE:
  266.     case MIPS_MAGIC_LITTLE2:
  267.     case MIPS_MAGIC_LITTLE3:
  268.       return abfd->xvec->byteorder_big_p == false;
  269.  
  270.     default:
  271.       return false;
  272.     }
  273. }
  274.  
  275. /* Reloc handling.  MIPS ECOFF relocs are packed into 8 bytes in
  276.    external form.  They use a bit which indicates whether the symbol
  277.    is external.  */
  278.  
  279. /* Swap a reloc in.  */
  280.  
  281. static void
  282. mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
  283.      bfd *abfd;
  284.      PTR ext_ptr;
  285.      struct internal_reloc *intern;
  286. {
  287.   const RELOC *ext = (RELOC *) ext_ptr;
  288.  
  289.   intern->r_vaddr = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_vaddr);
  290.   if (abfd->xvec->header_byteorder_big_p != false)
  291.     {
  292.       intern->r_symndx = (((int) ext->r_bits[0]
  293.                << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
  294.               | ((int) ext->r_bits[1]
  295.                  << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
  296.               | ((int) ext->r_bits[2]
  297.                  << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
  298.       intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
  299.             >> RELOC_BITS3_TYPE_SH_BIG);
  300.       intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
  301.     }
  302.   else
  303.     {
  304.       intern->r_symndx = (((int) ext->r_bits[0]
  305.                << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
  306.               | ((int) ext->r_bits[1]
  307.                  << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
  308.               | ((int) ext->r_bits[2]
  309.                  << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
  310.       intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
  311.             >> RELOC_BITS3_TYPE_SH_LITTLE);
  312.       intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
  313.     }
  314. }
  315.  
  316. /* Swap a reloc out.  */
  317.  
  318. static void
  319. mips_ecoff_swap_reloc_out (abfd, intern, dst)
  320.      bfd *abfd;
  321.      const struct internal_reloc *intern;
  322.      PTR dst;
  323. {
  324.   RELOC *ext = (RELOC *) dst;
  325.  
  326.   BFD_ASSERT (intern->r_extern
  327.           || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
  328.  
  329.   bfd_h_put_32 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
  330.   if (abfd->xvec->header_byteorder_big_p != false)
  331.     {
  332.       ext->r_bits[0] = intern->r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
  333.       ext->r_bits[1] = intern->r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
  334.       ext->r_bits[2] = intern->r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
  335.       ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
  336.              & RELOC_BITS3_TYPE_BIG)
  337.             | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
  338.     }
  339.   else
  340.     {
  341.       ext->r_bits[0] = intern->r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
  342.       ext->r_bits[1] = intern->r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
  343.       ext->r_bits[2] = intern->r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
  344.       ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
  345.              & RELOC_BITS3_TYPE_LITTLE)
  346.             | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
  347.     }
  348. }
  349.  
  350. /* Finish canonicalizing a reloc.  Part of this is generic to all
  351.    ECOFF targets, and that part is in ecoff.c.  The rest is done in
  352.    this backend routine.  It must fill in the howto field.  */
  353.  
  354. static void
  355. mips_adjust_reloc_in (abfd, intern, rptr)
  356.      bfd *abfd;
  357.      const struct internal_reloc *intern;
  358.      arelent *rptr;
  359. {
  360.   if (intern->r_type > MIPS_R_LITERAL)
  361.     abort ();
  362.  
  363.   if (! intern->r_extern
  364.       && (intern->r_type == MIPS_R_GPREL
  365.       || intern->r_type == MIPS_R_LITERAL))
  366.     rptr->addend += ecoff_data (abfd)->gp;
  367.  
  368.   /* If the type is MIPS_R_IGNORE, make sure this is a reference to
  369.      the absolute section so that the reloc is ignored.  */
  370.   if (intern->r_type == MIPS_R_IGNORE)
  371.     rptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
  372.  
  373.   rptr->howto = &mips_howto_table[intern->r_type];
  374. }
  375.  
  376. /* Make any adjustments needed to a reloc before writing it out.  None
  377.    are needed for MIPS.  */
  378.  
  379. static void
  380. mips_adjust_reloc_out (abfd, rel, intern)
  381.      bfd *abfd;
  382.      const arelent *rel;
  383.      struct internal_reloc *intern;
  384. {
  385. }
  386.  
  387. /* ECOFF relocs are either against external symbols, or against
  388.    sections.  If we are producing relocateable output, and the reloc
  389.    is against an external symbol, and nothing has given us any
  390.    additional addend, the resulting reloc will also be against the
  391.    same symbol.  In such a case, we don't want to change anything
  392.    about the way the reloc is handled, since it will all be done at
  393.    final link time.  Rather than put special case code into
  394.    bfd_perform_relocation, all the reloc types use this howto
  395.    function.  It just short circuits the reloc if producing
  396.    relocateable output against an external symbol.  */
  397.  
  398. static bfd_reloc_status_type
  399. mips_generic_reloc (abfd,
  400.             reloc_entry,
  401.             symbol,
  402.             data,
  403.             input_section,
  404.             output_bfd,
  405.             error_message)
  406.      bfd *abfd;
  407.      arelent *reloc_entry;
  408.      asymbol *symbol;
  409.      PTR data;
  410.      asection *input_section;
  411.      bfd *output_bfd;
  412.      char **error_message;
  413. {
  414.   if (output_bfd != (bfd *) NULL
  415.       && (symbol->flags & BSF_SECTION_SYM) == 0
  416.       && reloc_entry->addend == 0)
  417.     {
  418.       reloc_entry->address += input_section->output_offset;
  419.       return bfd_reloc_ok;
  420.     }
  421.  
  422.   return bfd_reloc_continue;
  423. }
  424.  
  425. /* Do a REFHI relocation.  This has to be done in combination with a
  426.    REFLO reloc, because there is a carry from the REFLO to the REFHI.
  427.    Here we just save the information we need; we do the actual
  428.    relocation when we see the REFLO.  MIPS ECOFF requires that the
  429.    REFLO immediately follow the REFHI, so this ought to work.  */
  430.  
  431. static bfd_byte *mips_refhi_addr;
  432. static bfd_vma mips_refhi_addend;
  433.  
  434. static bfd_reloc_status_type
  435. mips_refhi_reloc (abfd,
  436.           reloc_entry,
  437.           symbol,
  438.           data,
  439.           input_section,
  440.           output_bfd,
  441.           error_message)
  442.      bfd *abfd;
  443.      arelent *reloc_entry;
  444.      asymbol *symbol;
  445.      PTR data;
  446.      asection *input_section;
  447.      bfd *output_bfd;
  448.      char **error_message;
  449. {
  450.   bfd_reloc_status_type ret;
  451.   bfd_vma relocation;
  452.  
  453.   /* If we're relocating, and this an external symbol, we don't want
  454.      to change anything.  */
  455.   if (output_bfd != (bfd *) NULL
  456.       && (symbol->flags & BSF_SECTION_SYM) == 0
  457.       && reloc_entry->addend == 0)
  458.     {
  459.       reloc_entry->address += input_section->output_offset;
  460.       return bfd_reloc_ok;
  461.     }
  462.  
  463.   ret = bfd_reloc_ok;
  464.   if (symbol->section == &bfd_und_section
  465.       && output_bfd == (bfd *) NULL)
  466.     ret = bfd_reloc_undefined;
  467.  
  468.   if (bfd_is_com_section (symbol->section))
  469.     relocation = 0;
  470.   else
  471.     relocation = symbol->value;
  472.  
  473.   relocation += symbol->section->output_section->vma;
  474.   relocation += symbol->section->output_offset;
  475.   relocation += reloc_entry->addend;
  476.  
  477.   if (reloc_entry->address > input_section->_cooked_size)
  478.     return bfd_reloc_outofrange;
  479.  
  480.   /* Save the information, and let REFLO do the actual relocation.  */
  481.   mips_refhi_addr = (bfd_byte *) data + reloc_entry->address;
  482.   mips_refhi_addend = relocation;
  483.  
  484.   if (output_bfd != (bfd *) NULL)
  485.     reloc_entry->address += input_section->output_offset;
  486.  
  487.   return ret;
  488. }
  489.  
  490. /* Do a REFLO relocation.  This is a straightforward 16 bit inplace
  491.    relocation; this function exists in order to do the REFHI
  492.    relocation described above.  */
  493.  
  494. static bfd_reloc_status_type
  495. mips_reflo_reloc (abfd,
  496.           reloc_entry,
  497.           symbol,
  498.           data,
  499.           input_section,
  500.           output_bfd,
  501.           error_message)
  502.      bfd *abfd;
  503.      arelent *reloc_entry;
  504.      asymbol *symbol;
  505.      PTR data;
  506.      asection *input_section;
  507.      bfd *output_bfd;
  508.      char **error_message;
  509. {
  510.   if (mips_refhi_addr != (bfd_byte *) NULL)
  511.     {
  512.       unsigned long insn;
  513.       unsigned long val;
  514.       unsigned long vallo;
  515.  
  516.       /* Do the REFHI relocation.  Note that we actually don't need to
  517.      know anything about the REFLO itself, except where to find
  518.      the low 16 bits of the addend needed by the REFHI.  */
  519.       insn = bfd_get_32 (abfd, mips_refhi_addr);
  520.       vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
  521.            & 0xffff);
  522.       val = ((insn & 0xffff) << 16) + vallo;
  523.       val += mips_refhi_addend;
  524.  
  525.       /* The low order 16 bits are always treated as a signed value.
  526.      Therefore, a negative value in the low order bits requires an
  527.      adjustment in the high order bits.  We need to make this
  528.      adjustment in two ways: once for the bits we took from the
  529.      data, and once for the bits we are putting back in to the
  530.      data.  */
  531.       if ((vallo & 0x8000) != 0)
  532.     val -= 0x10000;
  533.       if ((val & 0x8000) != 0)
  534.     val += 0x10000;
  535.  
  536.       insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
  537.       bfd_put_32 (abfd, insn, mips_refhi_addr);
  538.  
  539.       mips_refhi_addr = (bfd_byte *) NULL;
  540.     }
  541.  
  542.   /* Now do the REFLO reloc in the usual way.  */
  543.   return mips_generic_reloc (abfd, reloc_entry, symbol, data,
  544.                   input_section, output_bfd, error_message);
  545. }
  546.  
  547. /* Do a GPREL relocation.  This is a 16 bit value which must become
  548.    the offset from the gp register.  */
  549.  
  550. static bfd_reloc_status_type
  551. mips_gprel_reloc (abfd,
  552.           reloc_entry,
  553.           symbol,
  554.           data,
  555.           input_section,
  556.           output_bfd,
  557.           error_message)
  558.      bfd *abfd;
  559.      arelent *reloc_entry;
  560.      asymbol *symbol;
  561.      PTR data;
  562.      asection *input_section;
  563.      bfd *output_bfd;
  564.      char **error_message;
  565. {
  566.   boolean relocateable;
  567.   bfd_vma relocation;
  568.   unsigned long val;
  569.   unsigned long insn;
  570.  
  571.   /* If we're relocating, and this is an external symbol with no
  572.      addend, we don't want to change anything.  We will only have an
  573.      addend if this is a newly created reloc, not read from an ECOFF
  574.      file.  */
  575.   if (output_bfd != (bfd *) NULL
  576.       && (symbol->flags & BSF_SECTION_SYM) == 0
  577.       && reloc_entry->addend == 0)
  578.     {
  579.       reloc_entry->address += input_section->output_offset;
  580.       return bfd_reloc_ok;
  581.     }
  582.  
  583.   if (output_bfd != (bfd *) NULL)
  584.     relocateable = true;
  585.   else
  586.     {
  587.       relocateable = false;
  588.       output_bfd = symbol->section->output_section->owner;
  589.     }
  590.  
  591.   if (symbol->section == &bfd_und_section
  592.       && relocateable == false)
  593.     return bfd_reloc_undefined;
  594.  
  595.   /* We have to figure out the gp value, so that we can adjust the
  596.      symbol value correctly.  We look up the symbol _gp in the output
  597.      BFD.  If we can't find it, we're stuck.  We cache it in the ECOFF
  598.      target data.  We don't need to adjust the symbol value for an
  599.      external symbol if we are producing relocateable output.  */
  600.   if (ecoff_data (output_bfd)->gp == 0
  601.       && (relocateable == false
  602.       || (symbol->flags & BSF_SECTION_SYM) != 0))
  603.     {
  604.       if (relocateable != false)
  605.     {
  606.       /* Make up a value.  */
  607.       ecoff_data (output_bfd)->gp =
  608.         symbol->section->output_section->vma + 0x4000;
  609.     }
  610.       else
  611.     {
  612.       unsigned int count;
  613.       asymbol **sym;
  614.       unsigned int i;
  615.  
  616.       count = bfd_get_symcount (output_bfd);
  617.       sym = bfd_get_outsymbols (output_bfd);
  618.  
  619.       if (sym == (asymbol **) NULL)
  620.         i = count;
  621.       else
  622.         {
  623.           for (i = 0; i < count; i++, sym++)
  624.         {
  625.           register CONST char *name;
  626.  
  627.           name = bfd_asymbol_name (*sym);
  628.           if (*name == '_' && strcmp (name, "_gp") == 0)
  629.             {
  630.               ecoff_data (output_bfd)->gp = bfd_asymbol_value (*sym);
  631.               break;
  632.             }
  633.         }
  634.         }
  635.  
  636.       if (i >= count)
  637.         {
  638.           /* Only get the error once.  */
  639.           ecoff_data (output_bfd)->gp = 4;
  640.           *error_message =
  641.         (char *) "GP relative relocation when _gp not defined";
  642.           return bfd_reloc_dangerous;
  643.         }
  644.     }
  645.     }
  646.  
  647.   if (bfd_is_com_section (symbol->section))
  648.     relocation = 0;
  649.   else
  650.     relocation = symbol->value;
  651.  
  652.   relocation += symbol->section->output_section->vma;
  653.   relocation += symbol->section->output_offset;
  654.  
  655.   if (reloc_entry->address > input_section->_cooked_size)
  656.     return bfd_reloc_outofrange;
  657.  
  658.   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
  659.  
  660.   /* Set val to the offset into the section or symbol.  */
  661.   val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
  662.   if (val & 0x8000)
  663.     val -= 0x10000;
  664.  
  665.   /* Adjust val for the final section location and GP value.  If we
  666.      are producing relocateable output, we don't want to do this for
  667.      an external symbol.  */
  668.   if (relocateable == false
  669.       || (symbol->flags & BSF_SECTION_SYM) != 0)
  670.     val += relocation - ecoff_data (output_bfd)->gp;
  671.  
  672.   insn = (insn &~ 0xffff) | (val & 0xffff);
  673.   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
  674.  
  675.   if (relocateable != false)
  676.     reloc_entry->address += input_section->output_offset;
  677.  
  678.   /* Make sure it fit in 16 bits.  */
  679.   if (val >= 0x8000 && val < 0xffff8000)
  680.     return bfd_reloc_overflow;
  681.  
  682.   return bfd_reloc_ok;
  683. }
  684.  
  685. /* Get the howto structure for a generic reloc type.  */
  686.  
  687. static CONST struct reloc_howto_struct *
  688. mips_bfd_reloc_type_lookup (abfd, code)
  689.      bfd *abfd;
  690.      bfd_reloc_code_real_type code;
  691. {
  692.   int mips_type;
  693.  
  694.   switch (code)
  695.     {
  696.     case BFD_RELOC_16:
  697.       mips_type = MIPS_R_REFHALF;
  698.       break;
  699.     case BFD_RELOC_32:
  700.       mips_type = MIPS_R_REFWORD;
  701.       break;
  702.     case BFD_RELOC_MIPS_JMP:
  703.       mips_type = MIPS_R_JMPADDR;
  704.       break;
  705.     case BFD_RELOC_HI16_S:
  706.       mips_type = MIPS_R_REFHI;
  707.       break;
  708.     case BFD_RELOC_LO16:
  709.       mips_type = MIPS_R_REFLO;
  710.       break;
  711.     case BFD_RELOC_MIPS_GPREL:
  712.       mips_type = MIPS_R_GPREL;
  713.       break;
  714.     case BFD_RELOC_MIPS_LITERAL:
  715.       mips_type = MIPS_R_LITERAL;
  716.       break;
  717.     default:
  718.       return (CONST struct reloc_howto_struct *) NULL;
  719.     }
  720.  
  721.   return &mips_howto_table[mips_type];
  722. }
  723.  
  724. /* A helper routine for mips_relocate_section which handles the REFHI
  725.    relocation.  The REFHI relocation must be followed by a REFLO
  726.    relocation, and the addend used is formed from the addends of both
  727.    instructions.  */
  728.  
  729. static void
  730. mips_relocate_refhi (refhi, reflo, input_bfd, input_section, contents,
  731.              relocation)
  732.      struct internal_reloc *refhi;
  733.      struct internal_reloc *reflo;
  734.      bfd *input_bfd;
  735.      asection *input_section;
  736.      bfd_byte *contents;
  737.      bfd_vma relocation;
  738. {
  739.   unsigned long insn;
  740.   unsigned long val;
  741.   unsigned long vallo;
  742.  
  743.   insn = bfd_get_32 (input_bfd,
  744.              contents + refhi->r_vaddr - input_section->vma);
  745.   vallo = (bfd_get_32 (input_bfd,
  746.                contents + reflo->r_vaddr - input_section->vma)
  747.        & 0xffff);
  748.   val = ((insn & 0xffff) << 16) + vallo;
  749.   val += relocation;
  750.  
  751.   /* The low order 16 bits are always treated as a signed value.
  752.      Therefore, a negative value in the low order bits requires an
  753.      adjustment in the high order bits.  We need to make this
  754.      adjustment in two ways: once for the bits we took from the data,
  755.      and once for the bits we are putting back in to the data.  */
  756.   if ((vallo & 0x8000) != 0)
  757.     val -= 0x10000;
  758.   if ((val & 0x8000) != 0)
  759.     val += 0x10000;
  760.  
  761.   insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
  762.   bfd_put_32 (input_bfd, (bfd_vma) insn,
  763.           contents + refhi->r_vaddr - input_section->vma);
  764. }
  765.  
  766. /* Relocate a section while linking a MIPS ECOFF file.  */
  767.  
  768. static boolean
  769. mips_relocate_section (output_bfd, info, input_bfd, input_section,
  770.                contents, external_relocs)
  771.      bfd *output_bfd;
  772.      struct bfd_link_info *info;
  773.      bfd *input_bfd;
  774.      asection *input_section;
  775.      bfd_byte *contents;
  776.      PTR external_relocs;
  777. {
  778.   asection **symndx_to_section;
  779.   struct ecoff_link_hash_entry **sym_hashes;
  780.   bfd_vma gp;
  781.   boolean gp_undefined;
  782.   struct external_reloc *ext_rel;
  783.   struct external_reloc *ext_rel_end;
  784.   boolean got_reflo;
  785.  
  786.   BFD_ASSERT (input_bfd->xvec->header_byteorder_big_p
  787.           == output_bfd->xvec->header_byteorder_big_p);
  788.  
  789.   /* We keep a table mapping the symndx found in an internal reloc to
  790.      the appropriate section.  This is faster than looking up the
  791.      section by name each time.  */
  792.   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
  793.   if (symndx_to_section == (asection **) NULL)
  794.     {
  795.       symndx_to_section = ((asection **)
  796.                bfd_alloc (input_bfd,
  797.                       (NUM_RELOC_SECTIONS
  798.                        * sizeof (asection *))));
  799.  
  800.       symndx_to_section[RELOC_SECTION_NONE] = NULL;
  801.       symndx_to_section[RELOC_SECTION_TEXT] =
  802.     bfd_get_section_by_name (input_bfd, ".text");
  803.       symndx_to_section[RELOC_SECTION_RDATA] =
  804.     bfd_get_section_by_name (input_bfd, ".rdata");
  805.       symndx_to_section[RELOC_SECTION_DATA] =
  806.     bfd_get_section_by_name (input_bfd, ".data");
  807.       symndx_to_section[RELOC_SECTION_SDATA] =
  808.     bfd_get_section_by_name (input_bfd, ".sdata");
  809.       symndx_to_section[RELOC_SECTION_SBSS] =
  810.     bfd_get_section_by_name (input_bfd, ".sbss");
  811.       symndx_to_section[RELOC_SECTION_BSS] =
  812.     bfd_get_section_by_name (input_bfd, ".bss");
  813.       symndx_to_section[RELOC_SECTION_INIT] =
  814.     bfd_get_section_by_name (input_bfd, ".init");
  815.       symndx_to_section[RELOC_SECTION_LIT8] =
  816.     bfd_get_section_by_name (input_bfd, ".lit8");
  817.       symndx_to_section[RELOC_SECTION_LIT4] =
  818.     bfd_get_section_by_name (input_bfd, ".lit4");
  819.       symndx_to_section[RELOC_SECTION_XDATA] = NULL;
  820.       symndx_to_section[RELOC_SECTION_PDATA] = NULL;
  821.       symndx_to_section[RELOC_SECTION_FINI] =
  822.     bfd_get_section_by_name (input_bfd, ".fini");
  823.       symndx_to_section[RELOC_SECTION_LITA] = NULL;
  824.       symndx_to_section[RELOC_SECTION_ABS] = NULL;
  825.  
  826.       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
  827.     }
  828.  
  829.   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
  830.  
  831.   gp = ecoff_data (output_bfd)->gp;
  832.   if (gp == 0)
  833.     gp_undefined = true;
  834.   else
  835.     gp_undefined = false;
  836.  
  837.   got_reflo = false;
  838.  
  839.   ext_rel = (struct external_reloc *) external_relocs;
  840.   ext_rel_end = ext_rel + input_section->reloc_count;
  841.   for (; ext_rel < ext_rel_end; ext_rel++)
  842.     {
  843.       struct internal_reloc int_rel;
  844.       struct internal_reloc reflo_int_rel;
  845.       bfd_vma addend;
  846.       reloc_howto_type *howto;
  847.       struct ecoff_link_hash_entry *h = NULL;
  848.       asection *s = NULL;
  849.       bfd_vma relocation;
  850.       bfd_reloc_status_type r;
  851.  
  852.       if (! got_reflo)
  853.     mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
  854.       else
  855.     {
  856.       int_rel = reflo_int_rel;
  857.       got_reflo = false;
  858.     }
  859.  
  860.       BFD_ASSERT (int_rel.r_type
  861.           < sizeof mips_howto_table / sizeof mips_howto_table[0]);
  862.  
  863.       /* The REFHI reloc requires special handling.  It must be
  864.      followed by a REFLO reloc, and the addend is formed from both
  865.      fields.  */
  866.       if (int_rel.r_type == MIPS_R_REFHI)
  867.     {
  868.       BFD_ASSERT ((ext_rel + 1) < ext_rel_end);
  869.       mips_ecoff_swap_reloc_in (input_bfd, (PTR) (ext_rel + 1),
  870.                     &reflo_int_rel);
  871.       BFD_ASSERT (reflo_int_rel.r_type == MIPS_R_REFLO
  872.               && int_rel.r_extern == reflo_int_rel.r_extern
  873.               && int_rel.r_symndx == reflo_int_rel.r_symndx);
  874.       got_reflo = true;
  875.     }
  876.  
  877.       howto = &mips_howto_table[int_rel.r_type];
  878.  
  879.       if (int_rel.r_extern)
  880.     {
  881.       h = sym_hashes[int_rel.r_symndx];
  882.       /* If h is NULL, that means that there is a reloc against an
  883.          external symbol which we thought was just a debugging
  884.          symbol.  This should not happen.  */
  885.       if (h == (struct ecoff_link_hash_entry *) NULL)
  886.         abort ();
  887.     }
  888.       else
  889.     {
  890.       if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
  891.         s = NULL;
  892.       else
  893.         s = symndx_to_section[int_rel.r_symndx];
  894.  
  895.       if (s == (asection *) NULL)
  896.         abort ();
  897.     }
  898.  
  899.       /* The GPREL reloc uses an addend: the difference in the GP
  900.      values.  */
  901.       if (int_rel.r_type != MIPS_R_GPREL)
  902.     addend = 0;
  903.       else
  904.     {
  905.       if (gp_undefined)
  906.         {
  907.           if (! ((*info->callbacks->reloc_dangerous)
  908.              (info, "GP relative relocation when GP not defined",
  909.               input_bfd, input_section,
  910.               int_rel.r_vaddr - input_section->vma)))
  911.         return false;
  912.           /* Only give the error once per link.  */
  913.           ecoff_data (output_bfd)->gp = gp = 4;
  914.           gp_undefined = false;
  915.         }
  916.       if (! int_rel.r_extern)
  917.         {
  918.           /* This is a relocation against a section.  The current
  919.          addend in the instruction is the difference between
  920.          INPUT_SECTION->vma and the GP value of INPUT_BFD.  We
  921.          must change this to be the difference between the
  922.          final definition (which will end up in RELOCATION)
  923.          and the GP value of OUTPUT_BFD (which is in GP).  */
  924.           addend = ecoff_data (input_bfd)->gp - gp;
  925.         }
  926.       else if (! info->relocateable
  927.            || h->root.type == bfd_link_hash_defined)
  928.         {
  929.           /* This is a relocation against an undefined or common
  930.          symbol.  The current addend in the instruction is
  931.          simply the desired offset into the symbol (normally
  932.          zero).  We are going to change this into a relocation
  933.          against a defined symbol, so we want the instruction
  934.          to hold the difference between the final definition
  935.          of the symbol (which will end up in RELOCATION) and
  936.          the GP value of OUTPUT_BFD (which is in GP).  */
  937.           addend = - gp;
  938.         }
  939.       else
  940.         {
  941.           /* This is a relocation against an undefined or common
  942.          symbol.  The current addend in the instruction is
  943.          simply the desired offset into the symbol (normally
  944.          zero).  We are generating relocateable output, and we
  945.          aren't going to define this symbol, so we just leave
  946.          the instruction alone.  */
  947.           addend = 0;
  948.         }
  949.     }
  950.  
  951.       if (info->relocateable)
  952.     {
  953.       /* We are generating relocateable output, and must convert
  954.          the existing reloc.  */
  955.       if (int_rel.r_extern)
  956.         {
  957.           if (h->root.type == bfd_link_hash_defined)
  958.         {
  959.           asection *hsec;
  960.           const char *name;
  961.  
  962.           /* This symbol is defined in the output.  Convert
  963.              the reloc from being against the symbol to being
  964.              against the section.  */
  965.  
  966.           /* Clear the r_extern bit.  */
  967.           int_rel.r_extern = 0;
  968.  
  969.           /* Compute a new r_symndx value.  */
  970.           hsec = h->root.u.def.section;
  971.           name = bfd_get_section_name (output_bfd,
  972.                            hsec->output_section);
  973.  
  974.           int_rel.r_symndx = -1;
  975.           switch (name[1])
  976.             {
  977.             case 'b':
  978.               if (strcmp (name, ".bss") == 0)
  979.             int_rel.r_symndx = RELOC_SECTION_BSS;
  980.               break;
  981.             case 'd':
  982.               if (strcmp (name, ".data") == 0)
  983.             int_rel.r_symndx = RELOC_SECTION_DATA;
  984.               break;
  985.             case 'f':
  986.               if (strcmp (name, ".fini") == 0)
  987.             int_rel.r_symndx = RELOC_SECTION_FINI;
  988.               break;
  989.             case 'i':
  990.               if (strcmp (name, ".init") == 0)
  991.             int_rel.r_symndx = RELOC_SECTION_INIT;
  992.               break;
  993.             case 'l':
  994.               if (strcmp (name, ".lit8") == 0)
  995.             int_rel.r_symndx = RELOC_SECTION_LIT8;
  996.               else if (strcmp (name, ".lit4") == 0)
  997.             int_rel.r_symndx = RELOC_SECTION_LIT4;
  998.               break;
  999.             case 'r':
  1000.               if (strcmp (name, ".rdata") == 0)
  1001.             int_rel.r_symndx = RELOC_SECTION_RDATA;
  1002.               break;
  1003.             case 's':
  1004.               if (strcmp (name, ".sdata") == 0)
  1005.             int_rel.r_symndx = RELOC_SECTION_SDATA;
  1006.               else if (strcmp (name, ".sbss") == 0)
  1007.             int_rel.r_symndx = RELOC_SECTION_SBSS;
  1008.               break;
  1009.             case 't':
  1010.               if (strcmp (name, ".text") == 0)
  1011.             int_rel.r_symndx = RELOC_SECTION_TEXT;
  1012.               break;
  1013.             }
  1014.               
  1015.           if (int_rel.r_symndx == -1)
  1016.             abort ();
  1017.  
  1018.           /* Add the section VMA and the symbol value.  */
  1019.           relocation = (h->root.u.def.value
  1020.                 + hsec->output_section->vma
  1021.                 + hsec->output_offset);
  1022.         }
  1023.           else
  1024.         {
  1025.           /* Change the symndx value to the right one for the
  1026.              output BFD.  */
  1027.           int_rel.r_symndx = h->indx;
  1028.           if (int_rel.r_symndx == -1)
  1029.             {
  1030.               /* This symbol is not being written out.  */
  1031.               if (! ((*info->callbacks->unattached_reloc)
  1032.                  (info, h->root.root.string, input_bfd,
  1033.                   input_section,
  1034.                   int_rel.r_vaddr - input_section->vma)))
  1035.             return false;
  1036.               int_rel.r_symndx = 0;
  1037.             }
  1038.           relocation = 0;
  1039.         }
  1040.         }
  1041.       else
  1042.         {
  1043.           /* This is a relocation against a section.  Adjust the
  1044.          value by the amount the section moved.  */
  1045.           relocation = (s->output_section->vma
  1046.                 + s->output_offset
  1047.                 - s->vma);
  1048.         }
  1049.  
  1050.       relocation += addend;
  1051.  
  1052.       /* Adjust the contents.  */
  1053.       if (relocation == 0)
  1054.         r = bfd_reloc_ok;
  1055.       else
  1056.         {
  1057.           if (int_rel.r_type != MIPS_R_REFHI)
  1058.         r = _bfd_relocate_contents (howto, input_bfd, relocation,
  1059.                         (contents
  1060.                          + int_rel.r_vaddr
  1061.                          - input_section->vma));
  1062.           else
  1063.         {
  1064.           mips_relocate_refhi (&int_rel, &reflo_int_rel,
  1065.                        input_bfd, input_section, contents,
  1066.                        relocation);
  1067.           r = bfd_reloc_ok;
  1068.         }
  1069.         }
  1070.  
  1071.       /* Adjust the reloc address.  */
  1072.       int_rel.r_vaddr += (input_section->output_section->vma
  1073.                   + input_section->output_offset
  1074.                   - input_section->vma);
  1075.  
  1076.       /* Save the changed reloc information.  */
  1077.       mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
  1078.     }
  1079.       else
  1080.     {
  1081.       /* We are producing a final executable.  */
  1082.       if (int_rel.r_extern)
  1083.         {
  1084.           /* This is a reloc against a symbol.  */
  1085.           if (h->root.type == bfd_link_hash_defined)
  1086.         {
  1087.           asection *hsec;
  1088.  
  1089.           hsec = h->root.u.def.section;
  1090.           relocation = (h->root.u.def.value
  1091.                 + hsec->output_section->vma
  1092.                 + hsec->output_offset);
  1093.         }
  1094.           else
  1095.         {
  1096.           if (! ((*info->callbacks->undefined_symbol)
  1097.              (info, h->root.root.string, input_bfd,
  1098.               input_section,
  1099.               int_rel.r_vaddr - input_section->vma)))
  1100.             return false;
  1101.           relocation = 0;
  1102.         }
  1103.         }
  1104.       else
  1105.         {
  1106.           /* This is a reloc against a section.  */
  1107.           relocation = (s->output_section->vma
  1108.                 + s->output_offset
  1109.                 - s->vma);
  1110.  
  1111.           /* Adjust a PC relative relocation by removing the
  1112.          reference to the original source section.  */
  1113.           if (howto->pc_relative)
  1114.         relocation += input_section->vma;
  1115.         }
  1116.  
  1117.       if (int_rel.r_type != MIPS_R_REFHI)
  1118.         r = _bfd_final_link_relocate (howto,
  1119.                       input_bfd,
  1120.                       input_section,
  1121.                       contents,
  1122.                       int_rel.r_vaddr - input_section->vma,
  1123.                       relocation,
  1124.                       addend);
  1125.       else
  1126.         {
  1127.           mips_relocate_refhi (&int_rel, &reflo_int_rel, input_bfd,
  1128.                    input_section, contents, relocation);
  1129.           r = bfd_reloc_ok;
  1130.         }
  1131.     }
  1132.  
  1133.       if (r != bfd_reloc_ok)
  1134.     {
  1135.       switch (r)
  1136.         {
  1137.         default:
  1138.         case bfd_reloc_outofrange:
  1139.           abort ();
  1140.         case bfd_reloc_overflow:
  1141.           if (! ((*info->callbacks->reloc_overflow)
  1142.              (info, input_bfd, input_section,
  1143.               int_rel.r_vaddr - input_section->vma)))
  1144.         return false;
  1145.           break;
  1146.         }
  1147.     }
  1148.     }
  1149.  
  1150.   return true;
  1151. }
  1152.  
  1153. /* This is the ECOFF backend structure.  The backend field of the
  1154.    target vector points to this.  */
  1155.  
  1156. static const struct ecoff_backend_data mips_ecoff_backend_data =
  1157. {
  1158.   /* COFF backend structure.  */
  1159.   {
  1160.     (void (*) PARAMS ((bfd *,PTR,int,int,PTR))) bfd_void, /* aux_in */
  1161.     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
  1162.     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
  1163.     (unsigned (*) PARAMS ((bfd *,PTR,int,int,PTR))) bfd_void, /* aux_out */
  1164.     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
  1165.     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
  1166.     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
  1167.     mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
  1168.     mips_ecoff_swap_scnhdr_out,
  1169.     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, true,
  1170.     mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
  1171.     mips_ecoff_swap_scnhdr_in, mips_ecoff_bad_format_hook,
  1172.     ecoff_set_arch_mach_hook, ecoff_mkobject_hook,
  1173.     ecoff_styp_to_sec_flags, ecoff_make_section_hook, ecoff_set_alignment_hook,
  1174.     ecoff_slurp_symbol_table, NULL, NULL
  1175.   },
  1176.   /* Supported architecture.  */
  1177.   bfd_arch_mips,
  1178.   /* Initial portion of armap string.  */
  1179.   "__________",
  1180.   /* The page boundary used to align sections in a demand-paged
  1181.      executable file.  E.g., 0x1000.  */
  1182.   0x1000,
  1183.   /* True if the .rdata section is part of the text segment, as on the
  1184.      Alpha.  False if .rdata is part of the data segment, as on the
  1185.      MIPS.  */
  1186.   false,
  1187.   /* Bitsize of constructor entries.  */
  1188.   32,
  1189.   /* Reloc to use for constructor entries.  */
  1190.   &mips_howto_table[MIPS_R_REFWORD],
  1191.   {
  1192.     /* Symbol table magic number.  */
  1193.     magicSym,
  1194.     /* Alignment of debugging information.  E.g., 4.  */
  1195.     4,
  1196.     /* Sizes of external symbolic information.  */
  1197.     sizeof (struct hdr_ext),
  1198.     sizeof (struct dnr_ext),
  1199.     sizeof (struct pdr_ext),
  1200.     sizeof (struct sym_ext),
  1201.     sizeof (struct opt_ext),
  1202.     sizeof (struct fdr_ext),
  1203.     sizeof (struct rfd_ext),
  1204.     sizeof (struct ext_ext),
  1205.     /* Functions to swap in external symbolic data.  */
  1206.     ecoff_swap_hdr_in,
  1207.     ecoff_swap_dnr_in,
  1208.     ecoff_swap_pdr_in,
  1209.     ecoff_swap_sym_in,
  1210.     ecoff_swap_opt_in,
  1211.     ecoff_swap_fdr_in,
  1212.     ecoff_swap_rfd_in,
  1213.     ecoff_swap_ext_in,
  1214.     /* Functions to swap out external symbolic data.  */
  1215.     ecoff_swap_hdr_out,
  1216.     ecoff_swap_dnr_out,
  1217.     ecoff_swap_pdr_out,
  1218.     ecoff_swap_sym_out,
  1219.     ecoff_swap_opt_out,
  1220.     ecoff_swap_fdr_out,
  1221.     ecoff_swap_rfd_out,
  1222.     ecoff_swap_ext_out
  1223.   },
  1224.   /* External reloc size.  */
  1225.   RELSZ,
  1226.   /* Reloc swapping functions.  */
  1227.   mips_ecoff_swap_reloc_in,
  1228.   mips_ecoff_swap_reloc_out,
  1229.   /* Backend reloc tweaking.  */
  1230.   mips_adjust_reloc_in,
  1231.   mips_adjust_reloc_out,
  1232.   /* Relocate section contents while linking.  */
  1233.   mips_relocate_section
  1234. };
  1235.  
  1236. /* Looking up a reloc type is MIPS specific.  */
  1237. #define ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
  1238.  
  1239. /* Getting relocated section contents is generic.  */
  1240. #define ecoff_bfd_get_relocated_section_contents \
  1241.   bfd_generic_get_relocated_section_contents
  1242.  
  1243. /* Core file support is usually traditional (but note that Irix uses
  1244.    irix-core.c).  */
  1245. #define ecoff_core_file_p _bfd_dummy_target
  1246. #define ecoff_core_file_failing_command    _bfd_dummy_core_file_failing_command
  1247. #define ecoff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
  1248. #define ecoff_core_file_matches_executable_p \
  1249.   _bfd_dummy_core_file_matches_executable_p
  1250.  
  1251. bfd_target ecoff_little_vec =
  1252. {
  1253.   "ecoff-littlemips",        /* name */
  1254.   bfd_target_ecoff_flavour,
  1255.   false,            /* data byte order is little */
  1256.   false,            /* header byte order is little */
  1257.  
  1258.   (HAS_RELOC | EXEC_P |        /* object flags */
  1259.    HAS_LINENO | HAS_DEBUG |
  1260.    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
  1261.  
  1262.   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect
  1263.                                 flags */
  1264.   0,                /* leading underscore */
  1265.   ' ',                /* ar_pad_char */
  1266.   15,                /* ar_max_namelen */
  1267.   4,                /* minimum alignment power */
  1268.   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  1269.      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  1270.      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
  1271.   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  1272.      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  1273.      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
  1274.  
  1275.   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
  1276.      ecoff_archive_p, _bfd_dummy_target},
  1277.   {bfd_false, ecoff_mkobject,  /* bfd_set_format */
  1278.      _bfd_generic_mkarchive, bfd_false},
  1279.   {bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
  1280.      _bfd_write_archive_contents, bfd_false},
  1281.   JUMP_TABLE (ecoff),
  1282.   (PTR) &mips_ecoff_backend_data
  1283. };
  1284.  
  1285. bfd_target ecoff_big_vec =
  1286. {
  1287.   "ecoff-bigmips",        /* name */
  1288.   bfd_target_ecoff_flavour,
  1289.   true,                /* data byte order is big */
  1290.   true,                /* header byte order is big */
  1291.  
  1292.   (HAS_RELOC | EXEC_P |        /* object flags */
  1293.    HAS_LINENO | HAS_DEBUG |
  1294.    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
  1295.  
  1296.   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect flags */
  1297.   0,                /* leading underscore */
  1298.   ' ',                /* ar_pad_char */
  1299.   15,                /* ar_max_namelen */
  1300.   4,                /* minimum alignment power */
  1301.   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  1302.      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  1303.      bfd_getb16, bfd_getb_signed_16, bfd_putb16,
  1304.   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  1305.      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  1306.      bfd_getb16, bfd_getb_signed_16, bfd_putb16,
  1307.  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
  1308.     ecoff_archive_p, ecoff_core_file_p},
  1309.  {bfd_false, ecoff_mkobject, /* bfd_set_format */
  1310.     _bfd_generic_mkarchive, bfd_false},
  1311.  {bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
  1312.     _bfd_write_archive_contents, bfd_false},
  1313.   JUMP_TABLE(ecoff),
  1314.   (PTR) &mips_ecoff_backend_data
  1315.   /* Note that there is another bfd_target just above this one.  If
  1316.      you are adding initializers here, you should be adding them there
  1317.      as well.  */
  1318. };
  1319.